home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part2 / 11551 < prev    next >
Encoding:
Text File  |  1996-08-05  |  3.9 KB  |  145 lines
  1. Path: fido.asd.sgi.com!news
  2. From: Emmanuel Mogenet <mgix@aw.sgi.com>
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: C++ Shortcomings ?
  5. Date: Fri, 15 Mar 1996 01:48:10 -0800
  6. Organization: Alias Wavefront
  7. Message-ID: <31493CDA.41C6@aw.sgi.com>
  8. References: <31488E8D.167E@aw.sgi.com> <4iaqch$moh@B1FF.mindspring.com>
  9. NNTP-Posting-Host: fddi-sgigate.sgi.com
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=us-ascii
  12. Content-Transfer-Encoding: 7bit
  13. X-Mailer: Mozilla 2.0 (X11; I; IRIX 5.3 IP22)
  14.  
  15. Justin Rudd wrote:
  16. > 
  17. > Emmanuel Mogenet <mgix@aw.sgi.com> wrote:
  18. > 
  19. > >In other word, make portions of the interface to a class private to
  20. > >only some classes.
  21. > 
  22. > >        1. Wouldn't that be nicer than the friend mechanism that cracks
  23. > >           open a class a spill its guts ?
  24. > >        2. Is there a clean way to achieve in today's C++ standard ?
  25. > >        3. Or is it a bad idea altogether ?
  26. > 
  27. > I'm not sure what you mean by this...You want to have a function
  28. > SomeMethodOnlyCallableByManagerForClassA();  That can be called like
  29. > this:
  30. > 
  31. > ManagerForClassA manage;
  32. > manage.SomeMethodOnlyCallableByManagerForClassA();
  33. > 
  34. > hm...OH WAIT...I get it....
  35. > 
  36. > even though ManagerForClassA has no idea what it has inside it should
  37. > still be able to call a member function of A.
  38. > 
  39. > Well this could be simulate using inheritance.  Hm...I've never really
  40. > thought about this...let me get back to you on this one.
  41.  
  42. No.
  43.  
  44. I guess my post was messy and unclear.
  45. What I want is to be able for a class A to tell:
  46.  
  47.  
  48. class A
  49. {
  50. restricted B:
  51.     void    DoSomething();
  52. }
  53.  
  54. This means: Ok, the method A::DoSomething is public, but not
  55. public for everybody. Only members of class B can have access to
  56. this method.
  57.  
  58. It's a bit like the friend operator, but instead of spilling
  59. everything to the friend, we just let him peep through a specialized window.
  60.  
  61. > 
  62. > >2. Pointer type manipulation
  63. > >-----------------------------
  64. > 
  65. > >A very disappointing thing in C++ (unless I am mistaken and it is actually
  66. > >possible to do so) is the following situation:
  67. > 
  68. > >If A is a class, then most operations on A can be redefined.
  69. > >Because A is a full blown type.
  70. > 
  71. > >Sadly, the same can not be said about A* (type: pointer to A).
  72. > 
  73. > >Even though A* is a type, none of its default manipulations
  74. > >can be redefined.
  75. > 
  76. > >Example: You can tell C++, that you want to gain control of the
  77. > >situation whenever an object of type A is duplicated.
  78. > 
  79. > >You do so by redefining the default copy constructor and the default
  80. > >assignment operator.
  81. > 
  82. > >But can you tell C++ that you want to gain control whenever a pointer of
  83. > >A* is duplicated ? Why can't I redefine the copy constructor for the type A* ?
  84. > 
  85. > >In my way of looking at thing, that'd be a *great* way of doing clean reference
  86. > >counting, instead of half-baked method using a redefinition of operator->.
  87. > 
  88. > >Comments ?
  89. > 
  90. > Ok...so you are saying you can do something like this...
  91.  
  92. 8< ... snip snip ... 8<
  93.  
  94. No.
  95.  
  96. What I meant was: I would like to be able to redefine the default
  97. copy constructor for pointers.
  98.  
  99. In other words, when I write:
  100. class A
  101. {
  102. };
  103.  
  104. main()
  105. {
  106.     A    *a;
  107.     B    *b;
  108.  
  109.     a=new A();
  110.     b=a;
  111. }
  112.  
  113. I want the compiler to trap this for me and give me control.
  114. What I really want the compiler to do is:
  115.  
  116. main()
  117. {
  118.     1. Call the constructor of object A* (that's what we do. We build an A*)
  119.     2. Call the constructor of object B*
  120.  
  121.     Call the constructor for object A* (to temporarily store the result of new)
  122.     Call the assignment method (to assign the result of new to a)
  123.     Call the assignment operator (to assign the value of a to b)
  124.     
  125. }
  126.  
  127. Another way to put it:
  128. I would like to be able to write
  129.  
  130. class A*
  131. {
  132.     A*();        // To build a pointer to A
  133.     A*(const A*&)    // To build an A* from another A*
  134.     ~A*();        // To get hold of what happens when a pointer to A goes out of scope
  135.  
  136.     A* operator=(const A*&);    // To redefine assignment
  137.     
  138. }
  139.  
  140.  
  141. All this complicated mechanics would allow to build
  142. industrial-strength reference counting on objects.
  143.  
  144.     - Mgix
  145.